﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloInstance
{
    public class SingletonClass { }
    /// <summary>
    /// lazy 式
    ///  优点：线程安全的单例，同时他的性能较好。
    ///  缺点：这里使用.NET4 或者更高版本,可以使用System.Lazy 这个类型声明
    /// </summary>
    public class SingletonClassLazy
    {
        private SingletonClassLazy() { }//私有的构造函数，防止用new关键字声明对象
        private static readonly Lazy<SingletonClassLazy> _lazy = new Lazy<SingletonClassLazy>(() => new SingletonClassLazy());
        public static SingletonClassLazy Instance { get { return _lazy.Value; } }
    }

    /// <summary>
    /// 懒汉式(双重检查锁定)
    /// 优点：可以保证线程安全，并且实例在需要时才会创建，不会造成内存浪费。
    /// 缺点：由于使用了锁，会引入额外的性能开销。
    /// </summary>
    public class SingletonClassIdler
    {
        private SingletonClassIdler() { }//私有的构造函数，防止用new关键字声明对象
        private static volatile SingletonClassIdler _instance = null;
        private static object instanceLock = new object();

        public static SingletonClassIdler Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (instanceLock)
                    {
                        if (_instance == null)
                            _instance = new SingletonClassIdler();
                    }
                }
                return _instance;
            }
        }
    }

    /// <summary>
    /// 饿汉式
    /// 优点：实例在类加载的时候就已经创建好了，并且线程安全。
    /// 缺点：实例在类加载的时候就已经创建好了，如果不使用造成资源浪费。
    /// </summary>
    /// </summary>
    public class SingletonClassHunger
    {
        private SingletonClassHunger() { }//私有的构造函数，防止用new关键字声明对象
        private static SingletonClassHunger instance = new SingletonClassHunger();
        public static SingletonClassHunger Instance { get { return instance; } }
    }

    /// <summary>
    /// 内部类
    /// 借助类的实例化机制, 在未使用的时候, 不会占用内存, 实现懒汉式。
    /// </summary>
    /// </summary>
    public class SingletonClassInner
    {
        private SingletonClassInner() { }//私有的构造函数，防止用new关键字声明对象
        public static SingletonClassInner Instance { get { return InnerClass._instance; } }

        private class InnerClass // 定义成员类
        {
            public static readonly SingletonClassInner _instance = new SingletonClassInner();//声明私有化静态字段
        }
    }

    /// <summary>
    /// 泛型单例 (内部实现可任选)
    /// Singleton<MyClass>.Instance;
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public sealed class Singleton<T> where T : class, new()
    {
        private Singleton() { }
        private static readonly Lazy<T> _lazy = new Lazy<T>(() => new T());
        public static T Instance { get { return _lazy.Value; } }
    }

    /// <summary>
    /// 泛型单例的抽象父类
    /// Singleton<MyClass>.Instance;
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class SingletonAbstract<T> where T : class, new()
    {
        protected SingletonAbstract() { }
        private static readonly Lazy<T> _lazy = new Lazy<T>(() => new T());
        public static T Instance { get { return _lazy.Value; } }
    }

    public class MySingleton : SingletonAbstract<MySingleton>
    {
    }


    /// <summary>
    /// 内部类
    /// </summary>
    public class Instance
    {
        private Instance() //一般私有化构造函数, 避免客户端直接new实例
        {
            Console.WriteLine("构造函数Instance 执行......");
        }
        //--------------重点---------------
        private class SubClass // 定义成员类
        {
            public static Instance _instance = new Instance();//声明私有化静态字段(也可以声明属性), 不赋值
        }
        public static Instance GetInstance() // 声明静态方法, 获取实例
        {
            return SubClass._instance;// 返回成员类字段(属性)
        }
        //--------------重点---------------
        public void Test()//声明个普通方法, 测试实例是否存在
        {
            Console.WriteLine("执行测试方法 .....");
        }
    }

}
